home *** CD-ROM | disk | FTP | other *** search
/ Inter.Net 55-1 / Inter.Net 55-1.iso / CBuilder / Setup / BCB / data.z / streambu.h < prev    next >
Encoding:
C/C++ Source or Header  |  1998-02-09  |  18.9 KB  |  852 lines
  1. #ifndef __STD_STREAMBUF__
  2. #define __STD_STREAMBUF__
  3. #pragma option push -b -a4 -Vx- -Ve- -w-inl -w-aus -w-sig
  4.  
  5. /***************************************************************************
  6.  *
  7.  * streambuf - Declarations for the Standard Library stream buffers
  8.  *
  9.  * $Id: streambuf,v 1.52 1996/09/24 19:18:25 smithey Exp $
  10.  *
  11.  ***************************************************************************
  12.  *
  13.  * (c) Copyright 1994, 1995 Rogue Wave Software, Inc.
  14.  * ALL RIGHTS RESERVED *
  15.  * The software and information contained herein are proprietary to, and
  16.  * comprise valuable trade secrets of, Rogue Wave Software, Inc., which
  17.  * intends to preserve as trade secrets such software and information.
  18.  * This software is furnished pursuant to a written license agreement and
  19.  * may be used, copied, transmitted, and stored only in accordance with
  20.  * the terms of such license and with the inclusion of the above copyright
  21.  * notice.  This software and information or any other copies thereof may
  22.  * not be provided or otherwise made available to any other person.
  23.  *
  24.  * Notwithstanding any other lease or license that may pertain to, or
  25.  * accompany the delivery of, this computer software and information, the
  26.  * rights of the Government regarding its use, reproduction and disclosure
  27.  * are as set forth in Section 52.227-19 of the FARS Computer
  28.  * Software-Restricted Rights clause.
  29.  * 
  30.  * Use, duplication, or disclosure by the Government is subject to
  31.  * restrictions as set forth in subparagraph (c)(1)(ii) of the Rights in
  32.  * Technical Data and Computer Software clause at DFARS 252.227-7013.
  33.  * Contractor/Manufacturer is Rogue Wave Software, Inc.,
  34.  * P.O. Box 2328, Corvallis, Oregon 97339.
  35.  *
  36.  * This computer software and information is distributed with "restricted
  37.  * rights."  Use, duplication or disclosure is subject to restrictions as
  38.  * set forth in NASA FAR SUP 18-52.227-79 (April 1985) "Commercial
  39.  * Computer Software-Restricted Rights (April 1985)."  If the Clause at
  40.  * 18-52.227-74 "Rights in Data General" is specified in the contract,
  41.  * then the "Alternate III" clause applies.
  42.  *
  43.  **************************************************************************/
  44.  
  45. #include <stdcomp.h>
  46.  
  47. #ifndef _RWSTD_NO_NEW_HEADER
  48. #include <cstdlib>
  49. #else
  50. #include <stdlib.h>
  51. #endif
  52.  
  53. #include <ios>
  54.  
  55. #ifndef _RWSTD_NO_NAMESPACE
  56. namespace std {
  57. #endif
  58.  
  59. template<class charT, class traits>
  60. class _RWSTDExportTemplate basic_streambuf {
  61.  
  62.   public:
  63.      
  64.     typedef charT                        char_type;
  65.     typedef traits                                traits_type;
  66.     typedef _TYPENAME traits::int_type              int_type;
  67.     typedef _TYPENAME traits::pos_type              pos_type;
  68.     typedef _TYPENAME traits::off_type              off_type;
  69.  
  70.  
  71. virtual ~basic_streambuf();
  72.  
  73. locale pubimbue( const locale& loc);
  74. locale getloc() const; 
  75.  
  76.  
  77. inline  basic_streambuf<char_type, traits> *
  78.          pubsetbuf(char_type *s, streamsize n);
  79.  
  80. inline pos_type pubseekoff(off_type off, ios_base::seekdir way,
  81.                            ios_base::openmode which =
  82.                    ios_base::in | ios_base::out);
  83.  
  84. inline pos_type pubseekpos(pos_type sp, ios_base::openmode which =
  85.                            ios_base::in | ios_base::out);
  86.  
  87. inline int pubsync( );
  88.  
  89. inline ios_base::openmode which_open_mode();
  90.  
  91. inline streamsize   in_avail();
  92.  
  93. inline int_type snextc();
  94.  
  95. inline int_type sbumpc();
  96.  
  97. inline int_type sgetc();
  98.  
  99. inline streamsize sgetn(char_type *s, streamsize n);
  100.  
  101. inline int_type sputbackc(char_type c);
  102.  
  103. inline int_type sungetc();
  104.  
  105. inline int_type sputc(char_type c);
  106.  
  107. inline streamsize sputn(const char_type *s, streamsize n);
  108.  
  109. #ifdef _RWSTD_MULTI_THREAD
  110.   _RWSTDMutex buffer_mutex_;
  111.  
  112.   void _RW_lock_buffer()
  113.   {
  114.     _RWSTDGuard* tmp = new _RWSTDGuard(buffer_mutex_);
  115.     if ( tmp )
  116.      buffer_guard = tmp;
  117.     else
  118.      buffer_guard = 0;
  119.   }
  120.  
  121.   void _RW_unlock_buffer()
  122.   {
  123.     if ( buffer_guard )
  124.      {
  125.        delete buffer_guard;
  126.        buffer_guard = 0;
  127.      }
  128.   }
  129.  
  130. #endif
  131.  
  132. protected:
  133.  
  134.     basic_streambuf();
  135.  
  136.     ios_base::openmode mode_;
  137.      
  138.     inline char_type *eback() const;    
  139.     inline char_type *gptr() const;
  140.     inline char_type *egptr() const;
  141.  
  142.     inline void gbump(int n);
  143.  
  144.     inline void setg(char_type *gbeg_arg,char_type *gnext_arg,char_type *gend_arg);
  145.  
  146.  
  147.     inline char_type *pbase() const;    
  148.     inline char_type *pptr() const;    
  149.     inline char_type *epptr() const;
  150.  
  151.     inline void pbump(int n);
  152.  
  153.     inline void setp(char_type *pbeg_arg,char_type *pend_arg);
  154.  
  155.    virtual void imbue( const locale& loc);
  156.     
  157.    virtual int_type overflow(int_type c = traits::eof());
  158.  
  159.    virtual int_type pbackfail(int_type c = traits::eof());
  160.  
  161.    virtual int showmanyc();
  162.  
  163.    virtual int_type underflow();
  164.  
  165.    virtual int_type uflow();
  166.  
  167.    virtual streamsize xsgetn(char_type *s, streamsize n);
  168.  
  169.    virtual streamsize xsputn(const char_type *s, streamsize n);
  170.  
  171.    virtual pos_type seekoff(off_type off,
  172.                             ios_base::seekdir way, ios_base::openmode which = 
  173.                             ios_base::in | ios_base::out);
  174.  
  175.     virtual pos_type seekpos(pos_type sp,
  176.                              ios_base::openmode which = 
  177.                              ios_base::in | ios_base::out);
  178.  
  179.     virtual basic_streambuf<charT, traits> *
  180.       setbuf(char_type *s, streamsize n);
  181.  
  182.  
  183.     virtual int sync( );
  184.  
  185.     void streambuf_init(bool set_mode= true);
  186.  
  187.   private:
  188.  
  189.     char_type       *gbeg_;    
  190.     char_type       *gnext_;  
  191.     char_type       *gend_;    
  192.  
  193.     char_type       *pbeg_;   
  194.     char_type       *pnext_;   
  195.     char_type       *pend_;  
  196.  
  197.     locale             loc_buf; 
  198.  
  199.     #ifdef _RWSTD_MULTI_THREAD
  200.      _RWSTDGuard *buffer_guard; 
  201.     #endif     
  202. };
  203.  
  204.  
  205. // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  206. // inline functions
  207. // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  208.  
  209. /*
  210.  * int_type snextc()
  211.  *
  212.  * returns the next character
  213.  */
  214.  
  215. template<class charT, class traits>
  216. inline _TYPENAME basic_streambuf<charT, traits>::int_type
  217. basic_streambuf<charT, traits>::snextc()
  218. {
  219.   if( traits::eq_int_type(sbumpc(),traits::eof()) )
  220.     return traits::eof();
  221.  
  222.   return sgetc();
  223. }
  224.  
  225. /*
  226.  * int_type sbumpc()
  227.  *
  228.  * returns the current character and increments the pointer
  229.  */
  230.  
  231. template<class charT, class traits>
  232. inline _TYPENAME basic_streambuf<charT, traits>::int_type
  233. basic_streambuf<charT, traits>::sbumpc()
  234. { 
  235.   char_type c;
  236.  
  237.   if( gptr()>= egptr()) {
  238.     return uflow();
  239.   } 
  240.  
  241.   c=*gptr();  
  242.   gbump(1); 
  243.   return traits::to_int_type(c);
  244. }
  245.  
  246. /*
  247.  * int_type sgetc()
  248.  *
  249.  * returns the current character
  250.  */
  251.  
  252. template<class charT, class traits>
  253. inline _TYPENAME basic_streambuf<charT, traits>::int_type
  254. basic_streambuf<charT, traits>::sgetc()
  255. {
  256.  
  257.   if(gptr() >= egptr()) {  
  258.     return underflow();
  259.   }
  260.  
  261.   return traits::to_int_type(*gptr());
  262. }
  263.  
  264. /*
  265.  * streamsize sgetn(char_type *, streamsize)
  266.  *
  267.  * reads in 'n' characters into 's'
  268.  */
  269.  
  270. template<class charT, class traits>
  271. inline streamsize basic_streambuf<charT, traits>::
  272. sgetn(char_type *s, streamsize n)
  273. {
  274.   return xsgetn(s, n);
  275. }
  276.  
  277.  
  278. /*
  279.  * int_type sputbackc(char_type)
  280.  *
  281.  * puts the character back into the sequence if possible
  282.  */
  283.  
  284. template<class charT, class traits>
  285. inline _TYPENAME basic_streambuf<charT, traits>::int_type
  286. basic_streambuf<charT, traits>::sputbackc(char_type c)
  287. {
  288.   if( gptr() > eback()) { 
  289.     gbump(-1);
  290.     if( !traits::eq(*gptr(),c) ) { 
  291.       gbump(1); 
  292.       return pbackfail(traits::to_int_type(c));
  293.     }
  294.  
  295.     return traits::to_int_type(*gptr());
  296.   }
  297.  
  298.   return pbackfail(traits::to_int_type(c)); 
  299. }
  300.  
  301.  
  302. /*
  303.  * int sungetc()
  304.  *
  305.  * puts the character back into the sequence. The putback character doesn't
  306.  * have to already be there.  Similar to sputbackc(...)
  307.  */
  308.  
  309. template<class charT, class traits>
  310. inline _TYPENAME basic_streambuf<charT, traits>::int_type
  311. basic_streambuf<charT, traits>::sungetc()
  312. {
  313.   if(gptr() > eback())
  314.      {
  315.         gbump(-1);
  316.         return traits::to_int_type(*gptr());
  317.      } 
  318.  
  319.   return pbackfail();
  320. }
  321.  
  322. /*
  323.  * int sputc(char_type)
  324.  *
  325.  * puts the character into the sequence
  326.  */
  327.  
  328. template<class charT, class traits>
  329. inline _TYPENAME basic_streambuf<charT, traits>::int_type
  330. basic_streambuf<charT, traits>::sputc(char_type c)
  331. {
  332.   
  333.   if( pptr() >= epptr() ) {
  334.     return overflow(traits::to_int_type(c));
  335.   }
  336.  
  337.  *pnext_++ =c; 
  338.  return traits::to_int_type(c);
  339. }
  340.  
  341. /*
  342.  * streamsize sputn(const char_type *, streamsize)
  343.  *
  344.  * writes n characters from s into the sequence
  345.  */
  346.  
  347. template<class charT, class traits>
  348. inline streamsize
  349. basic_streambuf<charT, traits>::sputn(const char_type *s, streamsize n)
  350. {
  351.   return xsputn(s, n);
  352. }
  353.  
  354. /*
  355.  * void gbump(int)
  356.  *
  357.  * increments the get pointer by n.  Does no checking to see if this
  358.  * is a valid operation
  359.  */
  360.  
  361. template<class charT, class traits>
  362. inline void 
  363. basic_streambuf<charT, traits>::gbump(int n)
  364. {
  365.   gnext_ += n;
  366. }
  367.  
  368. /*
  369.  * void setg(char_type *, char_type *, char_type *)
  370.  * 
  371.  * sets the get pointers
  372.  */
  373.  
  374. template<class charT, class traits>
  375. inline void 
  376. basic_streambuf<charT, traits>::
  377. setg(char_type *gbeg, char_type *gnext, char_type *gend)
  378. {
  379.   gbeg_ = gbeg;
  380.   gnext_ = gnext;
  381.   gend_ = gend;
  382. }
  383.  
  384.  
  385. /*
  386.  * void pbump(int)
  387.  *
  388.  * increments the put pointer.  No checking to see if this is valid
  389.  */
  390.  
  391. template<class charT, class traits>
  392. inline void 
  393. basic_streambuf<charT, traits>::pbump(int n)
  394. {
  395.   pnext_ += n;
  396. }
  397.  
  398. /*
  399.  * void setp(char_type *, char_type *)
  400.  *
  401.  * sets up the put pointers
  402.  */
  403.  
  404. template<class charT, class traits>
  405. inline void 
  406. basic_streambuf<charT, traits>::
  407. setp(char_type *pbeg, char_type *pend)
  408. {
  409.   pbeg_ = pbeg;
  410.   pnext_ = pbeg;
  411.   pend_ = pend;
  412. }
  413.  
  414. /*
  415.  * char_type *eback() const
  416.  *
  417.  * returns the beginning of the get sequence
  418.  */
  419.  
  420. template<class charT, class traits>
  421. inline _TYPENAME basic_streambuf<charT, traits>::char_type *
  422. basic_streambuf<charT, traits>::eback() const
  423. {
  424.   return gbeg_;
  425. }
  426.  
  427. /*
  428.  * char_type *gptr() const
  429.  */
  430.  
  431. template<class charT, class traits>
  432. inline _TYPENAME basic_streambuf<charT, traits>::char_type *
  433. basic_streambuf<charT, traits>::gptr() const
  434. {
  435.   return gnext_;
  436. }
  437.  
  438. /*
  439.  * char_type *egptr() const
  440.  */
  441.  
  442. template<class charT, class traits>
  443. inline _TYPENAME basic_streambuf<charT, traits>::char_type *
  444. basic_streambuf<charT, traits>::egptr() const
  445. {
  446.   return gend_;
  447. }
  448.  
  449. /*
  450.  * char_type *pbase() const
  451.  */
  452.  
  453. template<class charT, class traits>
  454. inline _TYPENAME basic_streambuf<charT, traits>::char_type *
  455. basic_streambuf<charT, traits>::pbase() const
  456. {
  457.   return pbeg_;
  458. }
  459.  
  460. /*
  461.  * char_type *pptr() const
  462.  */
  463.  
  464. template<class charT, class traits>
  465. inline _TYPENAME basic_streambuf<charT, traits>::char_type *
  466. basic_streambuf<charT, traits>::pptr() const
  467. {
  468.   return pnext_;
  469. }
  470.  
  471. /*
  472.  * char_type *epptr() const
  473.  */
  474.  
  475. template<class charT, class traits>
  476. inline _TYPENAME basic_streambuf<charT, traits>::char_type *
  477. basic_streambuf<charT, traits>::epptr() const
  478. {
  479.   return pend_;
  480. }
  481.  
  482.  
  483. /*
  484.  * streamsize in_avail()
  485.  *
  486.  * returns how many characters are available
  487.  */
  488.  
  489. template<class charT, class traits>
  490. inline streamsize 
  491. basic_streambuf<charT, traits>::in_avail()
  492. {
  493.   if(gptr() >= egptr())
  494.     return showmanyc();
  495.  
  496.   return ( (streamsize)(egptr() - gptr()) );
  497. }
  498.  
  499.  
  500. /*
  501.  * int pubsync()
  502.  */
  503.  
  504. template<class charT, class traits>
  505. inline int 
  506. basic_streambuf<charT, traits>::pubsync()
  507. {
  508.   return sync();
  509. }
  510.  
  511.  
  512. /*
  513.  * pos_type pubseekoff(off_type, ios_base::seekdir, ios_base::openmode)
  514.  */
  515.  
  516. template<class charT, class traits>
  517. inline _TYPENAME basic_streambuf<charT, traits>::pos_type
  518. basic_streambuf<charT, traits>::
  519. pubseekoff(off_type off, ios_base::seekdir way, ios_base::openmode which)
  520. {
  521.   return seekoff(off, way, which);
  522. }
  523.  
  524. /*
  525.  * pos_type pubseekpos(pos_type, ios_base::openmode)
  526.  */
  527. template<class charT, class traits>
  528. inline _TYPENAME basic_streambuf<charT, traits>::pos_type
  529. basic_streambuf<charT, traits>::
  530. pubseekpos(pos_type sp,
  531.            ios_base::openmode which)
  532. {
  533.   return seekpos(sp, which);
  534. }
  535.  
  536. /*
  537.  * basic_streambuf *pubsetbuf(char_type *, streamsize)
  538.  */
  539.  
  540. template<class charT, class traits>
  541. inline  basic_streambuf<charT, traits> *
  542. basic_streambuf<charT, traits>::
  543. pubsetbuf(char_type *s, streamsize n)
  544. {
  545.   return setbuf(s, n);
  546. }
  547.  
  548. /*
  549.  * ios_base::openmode which_open_mode()
  550.  */
  551.  
  552. template<class charT, class traits>
  553. inline ios_base::openmode
  554. basic_streambuf<charT, traits>::which_open_mode()
  555. {
  556.   return mode_; 
  557. }
  558.  
  559.  
  560. // END OF INLINE FUNCTIONS
  561.  
  562. /*
  563.  *   streambuf iterators
  564.  */
  565.  
  566. //
  567. // ostreambuf_iterator
  568. //
  569.  
  570. template<class charT, class traits >
  571. class _RWSTDExportTemplate ostreambuf_iterator : public output_iterator {
  572.  
  573.   public:
  574.  
  575.     typedef charT                          char_type;
  576.     typedef traits                         traits_type;
  577.     typedef basic_streambuf<charT, traits> streambuf_type;
  578.     typedef basic_ostream<charT, traits>   ostream_type;
  579.  
  580.     ostreambuf_iterator(ostream_type& s) _RWSTD_INLINE_NO_THROW
  581.     : sbuf_(s.rdbuf())
  582.     {
  583.        if ( s.rdbuf() ) failed_flag = false;
  584.        else 
  585.         failed_flag = true; 
  586.     }
  587.  
  588.     ostreambuf_iterator(streambuf_type *s) _RWSTD_INLINE_NO_THROW
  589.     : sbuf_(s)
  590.     { 
  591.       if ( s ) failed_flag = false;
  592.       else 
  593.        failed_flag = true;
  594.     }
  595.  
  596.     ostreambuf_iterator<charT,traits>& operator*()
  597.     { return *this; }
  598.     ostreambuf_iterator<charT,traits>& operator++()
  599.     { return *this; }
  600.     ostreambuf_iterator<charT,traits> operator++(int)
  601.     { return *this; }
  602.  
  603.     ostreambuf_iterator<charT,traits>& operator=(charT c)
  604.       { 
  605.         if ( !failed_flag )
  606.         {
  607.           if ( traits::eq_int_type(sbuf_->sputc(c),traits::eof()) )
  608.            failed_flag=true;
  609.         }
  610.         return *this;
  611.       }
  612.  
  613.     bool failed( ) const _RWSTD_INLINE_NO_THROW
  614.     { return failed_flag; }
  615.      
  616.  
  617.   protected:
  618.  
  619.   private:
  620.  
  621.     streambuf_type        *sbuf_;
  622.     bool                  failed_flag;
  623.  
  624. };
  625.  
  626. //
  627. // istreambuf_iterator 
  628. //
  629.  
  630. template<class charT, class traits >
  631. class _RWSTDExportTemplate istreambuf_iterator : public input_iterator<charT>
  632. {
  633.  
  634.   public:
  635.  
  636.     typedef charT                          char_type;
  637.     typedef _TYPENAME traits::int_type      int_type;
  638.     typedef traits                         traits_type;
  639.     typedef basic_streambuf<charT, traits> streambuf_type;
  640.     typedef basic_istream<charT, traits>   istream_type;
  641.  
  642.     // class to maintain a character and an associated streambuf
  643.     class proxy {
  644.  
  645.         char_type                      keep_;
  646.         streambuf_type             *sbuf_;
  647.  
  648.         proxy(char_type c, streambuf_type *sbuf)
  649.           : keep_(c), sbuf_(sbuf)
  650.           { ; }
  651.  
  652.       public:
  653.  
  654.         char_type operator*()
  655.           { return keep_; }
  656.  
  657.         friend class istreambuf_iterator<charT, traits>;
  658.  
  659.     };
  660.  
  661.   public:
  662.  
  663.     istreambuf_iterator()  _RWSTD_INLINE_NO_THROW
  664.     : sbuf_(0)
  665.     { failed_flag = true; }
  666.     istreambuf_iterator(istream_type& s)  _RWSTD_INLINE_NO_THROW
  667.     : sbuf_(s.rdbuf())
  668.     { 
  669.       if ( s.rdbuf() ) failed_flag = false;
  670.       else 
  671.        failed_flag = true; 
  672.     }
  673.     istreambuf_iterator(streambuf_type *s) _RWSTD_INLINE_NO_THROW
  674.     : sbuf_(s)
  675.     {
  676.       if ( s ) failed_flag = false;
  677.       else 
  678.        failed_flag = true;
  679.     }
  680.     istreambuf_iterator(const proxy& p) _RWSTD_INLINE_NO_THROW
  681.     : sbuf_(p.sbuf_)
  682.     { ; }
  683.     inline char_type operator*();
  684.     inline istreambuf_iterator<charT, traits>& operator++();
  685.     inline proxy operator++(int);
  686.     inline bool equal(istreambuf_iterator<charT, traits>& b);
  687.  
  688.     bool failed( ) const _RWSTD_INLINE_NO_THROW
  689.     { return failed_flag; }
  690.  
  691.   protected:
  692.  
  693.   private:
  694.  
  695.     streambuf_type     *sbuf_;
  696.     bool               failed_flag;
  697.  
  698. };
  699.  
  700. // +++++++++++++++++++++++++++++++++++++++++++++++++++++++
  701. // inline functions
  702. // +++++++++++++++++++++++++++++++++++++++++++++++++++++++
  703.  
  704. /*
  705.  * char_type operator*()
  706.  */
  707.  
  708. template<class charT, class traits>
  709. inline _TYPENAME istreambuf_iterator<charT, traits>::char_type
  710. istreambuf_iterator<charT, traits>::operator*()
  711. {
  712.   int_type c;
  713.  
  714.   if ( sbuf_ && !failed_flag )
  715.    {
  716.      c= sbuf_->sgetc();
  717.      if ( traits::eq_int_type(c,traits::eof()) ) 
  718.       {
  719.         sbuf_ = 0;
  720.         failed_flag = true;
  721.       }
  722.    }
  723.   else return traits::eof();
  724.  
  725.   return traits::to_char_type(c);
  726.   
  727. }
  728.  
  729. /*
  730.  * istreambuf_iterator& operator++()
  731.  */
  732.  
  733. template<class charT, class traits>
  734. inline istreambuf_iterator<charT, traits>&
  735. istreambuf_iterator<charT, traits>::operator++()
  736. {
  737.   if (sbuf_ && !failed_flag )
  738.    { 
  739.      sbuf_->sbumpc();
  740.      if ( traits::eq_int_type(sbuf_->sgetc(),traits::eof()) ) 
  741.       {
  742.         sbuf_ = 0;
  743.         failed_flag = true;
  744.       } 
  745.    }
  746.  
  747.   return *this;
  748. }
  749.  
  750. /*
  751.  * proxy operator++(int)
  752.  */
  753.  
  754. template<class charT, class traits>
  755. inline _TYPENAME istreambuf_iterator<charT, traits>::proxy 
  756. istreambuf_iterator<charT, traits>::operator++(int)
  757. {
  758.  
  759.   if (sbuf_ && !failed_flag )
  760.     {
  761.       proxy     prev(sbuf_->sgetc(), sbuf_);
  762.       sbuf_->sbumpc();
  763.       if ( traits::eq_int_type(sbuf_->sgetc(),traits::eof()) ) 
  764.       {
  765.         sbuf_ = 0;
  766.         failed_flag = true;
  767.       }  
  768.       return prev;
  769.     }
  770.     
  771.    charT     c=traits::to_char_type(traits::eof());
  772.    return proxy(c, sbuf_);
  773.     
  774.  
  775. }
  776.  
  777. /*
  778.  * bool equal(istreambuf_iterator&)
  779.  */
  780.  
  781. template<class charT, class traits>
  782. inline bool
  783. istreambuf_iterator<charT, traits>::
  784. equal(istreambuf_iterator<charT, traits>& b)
  785. {
  786.   if( ((sbuf_ ==0) && (b.sbuf_==0)) || ((sbuf_ !=0) && (b.sbuf_ !=0)) )
  787.     return true;  
  788.   else
  789.     return false;
  790. }
  791.  
  792.  
  793. /*
  794.  * bool operator==(istreambuf_iterator& a, istreambuf_iterator& b)
  795.  */
  796.  
  797. template<class charT, class traits>
  798. inline bool _RWSTDExportTemplate operator==(istreambuf_iterator<charT, traits>& a,
  799.                 istreambuf_iterator<charT, traits>& b)
  800. {
  801.   return a.equal(b);
  802. }
  803.  
  804.  
  805. /*
  806.  * bool operator!=(istreambuf_iterator& a, istreambuf_iterator& b)
  807.  */
  808.  
  809. template<class charT, class traits>
  810. inline bool _RWSTDExportTemplate operator!=(istreambuf_iterator<charT, traits>& a,
  811.                 istreambuf_iterator<charT, traits>& b)
  812. {
  813.   return !(a.equal(b));
  814. }
  815.  
  816. // end inlining
  817.  
  818.  
  819.  
  820. #ifndef _RWSTD_NO_COMPLEX_DEFAULT_TEMPLATES
  821. typedef basic_streambuf<char>                            streambuf;
  822. #else
  823. typedef basic_streambuf<char, char_traits<char> >         streambuf;
  824. #endif
  825.  
  826. #ifndef _RWSTD_NO_WIDE_CHAR
  827. #ifndef _RWSTD_NO_COMPLEX_DEFAULT_TEMPLATES
  828. typedef basic_streambuf<wchar_t>                         wstreambuf;
  829. #else
  830. typedef basic_streambuf<wchar_t, char_traits<wchar_t> >   wstreambuf;
  831. #endif
  832. #endif
  833.  
  834.  
  835. #ifndef _RWSTD_NO_NAMESPACE
  836. }
  837. #endif
  838.  
  839.  
  840.  
  841. #ifdef _RWSTD_COMPILE_INSTANTIATE
  842. #include <streambu.cc>
  843. #endif
  844.  
  845. #ifndef __USE_STD_NAMES__
  846.   using namespace std;
  847. #endif
  848.  
  849. #pragma option pop
  850.  
  851. #endif /* __STREAMBUF__ */
  852.